﻿#define _CRT_SECURE_NO_WARNINGS

//#include<iostream>
//using namespace std;
//class Date
//{
//public:
//	//构造函数
//	Date(int year,int month,int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	//拷贝构造函数-——特殊的构造函数
//	Date(Date& d)
//		//拷贝构造函数的参数只有⼀个，并且必须是类类型对象的引用
//	{
//		//用已经存在的对象去初始化新的对象
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//int main()
//{
//	Date d1(2024, 11, 11);//d1调用构造函数
//	Date d2(d1);//调用拷贝构造函数~用已经存在的对象去初始化新的对象
//	Date d3 = d1;//同样是调用拷贝构造函数~用已经存在的对象去初始化新的对象
//	d1.Print();
//	d2.Print();
//	d3.Print();
//	return 0;
//}


//#include<iostream>
//using namespace std;
//class Date
//{
//public:
//	//构造函数
//	Date(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	//拷贝构造函数-——特殊的构造函数
//	Date(Date& d)
//		//拷贝构造函数的参数只有⼀个，并且必须是类类型对象的引用
//	{
//		//用已经存在的对象去初始化新的对象
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//	
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
////Date DateCopy()
////{
////	Date d(2024, 2, 2);
////	return d;
////}//err
//
//int main()
//{
//	Date d1(2024, 11, 11);//d1调用构造函数
//	Date d2(d1);//调用拷贝构造函数~用已经存在的对象去初始化新的对象
//	Date d3 = d1;//同样是调用拷贝构造函数~用已经存在的对象去初始化新的对象
//	//Date d4 = DateCopy();//err
//	d1.Print();
//	d2.Print();
//	d3.Print();
//	return 0;
//}

//#include<iostream>
//using namespace std;
//class Date
//{
//public:
//	//构造函数
//	Date(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d1(2024, 11, 11);//d1调用构造函数
//	Date d2(d1);//调用编译器自动生成的拷贝构造函数
//	Date d3 = d1;//调用编译器自动生成的拷贝构造函数
//	//自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(⼀个字节⼀个字节的拷贝)
//	d1.Print();
//	d2.Print();
//	d3.Print();
//	return 0;
//}
//
// 
// 
//


//#include<iostream>
//using namespace std;
//class Date
//{
//public:
//	//构造函数（这里是全缺省参数，是默认构造函数的一种
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	//拷贝构造函数——已经存在的对象初始化一个新创建的对象
//	Date(const Date& d)
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//	Date(Date* d)
//	{
//		_year = d->_year;
//		_month = d->_month;
//		_day = d->_day;
//	}
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//
////void Func1(Date d)//调用拷贝构造完成拷贝（产生了一个临时对象）
//void Func1(Date& d)//使用引用传参优化，不需要拷贝构造，传自身，减少拷贝构造次数~
//{
//	cout << "&d" << endl;
//	cout << &d << endl;
//	cout << "d.Print()" << endl;
//	d.Print();
//}
//
//Date Func2()//返回对象也会调用拷贝构造函数（相当于产生了一个临时对象）
////Date& Func2()//使用引用返回，不需要拷贝构造，返回自身，存在问题//err
////问题：Func2函数结束，tmp对象就销毁了，相当于了⼀个野引用
//{
//	Date tmp(2024, 2, 2);
//	cout << "tmp.Print()" << endl;
//	tmp.Print();
//	return tmp;
//}
//int main()
//{
//	Date d1(2024, 11, 11);
//	cout << "d1.Print()" << endl;
//	d1.Print();
//	//d1传值传参给d要调用拷贝构造完成拷贝，使用传引用传参可以减少拷贝
//	cout << "&d1" << endl;
//	cout << &d1 << endl;
//	Func1(d1);
//
//	
//	Date ret = Func2();
//	cout << "ret.Print()" << endl;
//	ret.Print();
//	return 0;
//}



#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	//涉及资源，需要显示写拷贝构造函数
	Stack(const Stack& st)
	{
		// 需要对_a指向资源创建同样大的资源再拷贝
		_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		
		memcpy(_a, st._a, sizeof(STDataType) * st._top);
		_top = st._top;
		_capacity = st._capacity;
	}

	void Push(STDataType x)
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
				sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			_a = tmp;
			_capacity = newcapacity;
		}
		_a[_top++] = x;
	}
	//析构函数
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}

private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};

// 两个Stack实现队列
class MyQueue
{
public:
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	Stack st1;
	st1.Push(1);
	st1.Push(2);
	// 如果Stack不显示实现拷贝构造，那么会使用编译器自动生成的拷贝构造完成浅拷贝
	// 会导致st1和st2⾥⾯的_a指针指向同⼀块资源，析构时会析构两次，程序崩溃

	Stack st2 = st1;
	MyQueue mq1;
	// MyQueue自动生成的拷贝构造，会自动调用Stack拷贝构造完成pushst/popst
	// 的拷贝，只要Stack拷贝构造实现了深拷贝，就没问题~
	MyQueue mq2 = mq1;
	return 0;
}